﻿#coding:utf-8

from constants import *

class Ponto():

	def __init__(self,x,y,z=None,valor=None,cor=None):
		self.x = x
		self.y = y
		self.z = z
		
		self.cor = cor
		self.valor = valor
		
	def set_valor(self,valor):
		self.valor = valor
		
	def set_cor(self,cor):
		self.cor = cor
		
	def __getitem__(self,index):
		if index==0:
			return self.x
		elif index==1:
			return self.y
			
	def __setitem__(self,index,value):			
		if index==0:
			self.x = value
		elif index==1:
			self.y = value		
			
	def get_pair(self):
		return (self.x,self.y,self.z)

class ConjuntoPontos():
	
	def __init__(self,modo,cor):
		self.modo = modo		
		self.cor = cor
		self.pontos = []
		
	def add_ponto(self,pt):
		if pt.cor is None:
			pt.cor = self.cor
			
		self.pontos.append(pt)
		

class Plotador():	
	def __init__(self,size_x,size_y,rect):
		self.size_x = size_x
		self.size_y = size_y
		
		self.rect = rect
		
		self.titulo = "TITULO"
		self.labelY = "y"
		self.labelX = "x"
		
		self.cor = Cor.AZUL
		self.conjuntos = []	
		
		self._podePintar = True
		self._limpar = True
		self._plotar = False
				
		self.setModo(PONTO)
		
	def __getPontoNoPlano__(self,x,y):
		'''
			Dado um ponto no plano, retorna as coordenadas referentes a tela
		'''
		x_plano = (x - self.x_minus) / self.x_offset
		y_plano = self.size_y - ( (y - self.y_minus ) / self.y_offset )
		
		return (x_plano,y_plano)
		
	def __getPosNoPlano__(self,x,y):
		'''
			Dada uma posição na tela, retorna as coordenadas referentes ao plano
		'''
		x_rel,y_rel = self.__getPosRel__(x,y)
		ponto_x = self.x_offset*( x_rel - self.origem[0] )
		ponto_y = self.y_offset*( self.origem[1] - y_rel )
		
		return (ponto_x,ponto_y)
		
	def __getPosRel__(self,x,y):
		return (x-self.rect.x,y-self.rect.y)	

	def __zoom_in__(self):
		coord_x = (self.x_minus + (self.x_minus + self.x_large) )/2.0
		coord_y = (self.y_minus+ (self.y_minus + self.y_large) )/2.0

		new_x_minus = coord_x - (self.x_large*0.9)/2.0							
		new_x_large = (self.x_large*0.9)
		
		new_y_minus = coord_y - (self.y_large*0.9)/2.0
		new_y_large = self.y_large*0.9		
		
		self.gerarPlano( new_x_minus,new_x_large,new_y_minus,new_y_large )				
		
		self._podePintar = True
		self._limpar=True		
		self._plotar=True	

		
	def __zoom_out__(self):
		coord_x = (self.x_minus + (self.x_minus + self.x_large) )/2.0
		coord_y = (self.y_minus+ (self.y_minus + self.y_large) )/2.0

		new_x_minus = coord_x - (self.x_large*1.1)/2.0							
		new_x_large = (self.x_large*1.1)
		
		new_y_minus = coord_y - (self.y_large*1.1)/2.0
		new_y_large = self.y_large*1.1	
		
		self.gerarPlano( new_x_minus,new_x_large,new_y_minus,new_y_large )				
		
		self._podePintar = True
		self._limpar=True		
		self._plotar=True
		
	def __move__(self,rel_x,rel_y):
		x = -rel_x*self.x_offset
		y = rel_y*self.y_offset
		
		new_x_minus = self.x_minus + x
		new_y_minus = self.y_minus + y
		
		self.gerarPlano( new_x_minus,self.x_large,new_y_minus,self.y_large )				
		
		self._podePintar = True
		self._limpar=True		
		self._plotar=True			
						
	def gerarPlano(self,x_minus,x_large,y_minus,y_large):
		self.podePintar = False
		
		self.x_minus = x_minus
		self.x_large = x_large
		
		self.y_minus = y_minus
		self.y_large = y_large
		
		self.x_offset = x_large / float( self.size_x ) 
		self.y_offset = y_large / float( self.size_y ) 
		
			
		self.origem = self.__getPontoNoPlano__(0,0)
		
		self.podePintar = True
		
	def limpar(self):
		self._podePintar = True
		self._limpar = True
		
	def setModo(self,modo,funcao=None):
		self.modo = modo
		
		self.atual = None
		self.ultimo_ponto = None
		
		if funcao is not None:
			self.funcao = funcao		
		
	def setLabelX(self,labelX):
		self.labelX = labelX
		
	def setLabelY(self,labelY):
		self.labelY = labelY
		
	def setTitulo(self,titulo):
		self.titulo = titulo
		
	def limpar_conjuntos(self):
		self.conjuntos = []
		
	def iniciar_conjunto(self):
		self.conjunto_atual = ConjuntoPontos(self.modo,self.cor)
					
	def plotar(self,pt):
		self.conjunto_atual.add_ponto( pt )		
		
	def fechar_conjunto(self):
		self.conjuntos.append(self.conjunto_atual)
		
		self._plotar = True
		self._podePintar = True		
		
class InterfaceControls():	
	def __init__(self,controlAnalitico,controlNumerico):
		self.controlAnalitico = controlAnalitico
		self.controlNumerico = controlNumerico
		
	def plotar_grafico_v_x_analitico(self,y_fixed,termos):
		self.controlAnalitico.plotar_grafico_v_x( y_fixed,termos )
		
	def plotar_grafico_v_x_numerico(self,y_fixed):
		self.controlNumerico.plotar_grafico_v_x( y_fixed )

	def plotar_grafico_v_y_analitico(self,x_fixed,termos):	
		self.controlAnalitico.plotar_grafico_v_y(x_fixed,termos)
		
	def plotar_grafico_v_y_numerico(self,x_fixed):
		self.controlNumerico.plotar_grafico_v_y(x_fixed)
		
	def plotar_grafico_v_x_y_analitico(self,termos):
		self.controlAnalitico.plotar_grafico_v_x_y(termos)
		
	def plotar_grafico_v_x_y_numerico(self):
		self.controlNumerico.plotar_grafico_v_x_y()
		
	def plotar_campo_eletrico_analitico(self,termos):
		self.controlAnalitico.plotar_campo_eletrico(termos)

	def plotar_campo_eletrico_numerico(self):
		self.controlNumerico.plotar_campo_eletrico()		
		

		
			
		

